/**
 * 语言库数据
 *
 * export languages 所有语种，从 pc-fe 的window获取，没有就使用默认数据
 * export defaultCNKey 默认语言 zh
 * export DefaultLang 当前语言 {zh: '', en: '', ja: '', ko: ''} 格式数据
 * export message 语言库数据
 * export messageMap 语言库数据 以 emali.allocationTitle:'1111' 的形式数据
 *
 * 语言库查找数据 Start
 * export GetTransformI18n 查找当前语言库数据
 * export GetCommonDefaultLang 多语言 key-value 对象 { 'zh-CN': '', 'en-US': '', 'ja': '', 'ko': ''}
 * 语言库查找数据 End
 *
 * 下拉菜单数据处理 Start
 * export initOptionLanguage
 * export formatLanguage
 * export getDefaultLangOpts
 * 下拉菜单数据处理 End
 */
import { getRootWindow } from '@src/util/dom';
import oldLanguage from 'pub-bbx-global/lang/dist/project/fe';
import { translateLanguage } from 'pub-bbx-global/lang/dist/utils/languageList';
import { lastCoverLanguage } from 'pub-bbx-global/lang/dist/utils/config';
import { transformI18n } from '@src/locales'
import { isObject, isArray } from '@src/util/type'
import { useFormMultiLanguage } from '@hooks/useFormMultiLanguage'
const { internationalGray } = useFormMultiLanguage()

import _ from 'lodash';

// 获取多语言种类
const defaultLanguages = translateLanguage;

const rootWindow = getRootWindow(window);
// 当前语言
export const languages = rootWindow?.languages || defaultLanguages;

// 灰度
export const isOpenMultiLanguage = rootWindow?.grayAuth?.multiLanguage || true;

export const defaultLanguageObj = languages && languages.find(item => item.isMainLanguage);

// 默认语种
export const defaultCNKey =
  (defaultLanguageObj && defaultLanguageObj.languageKey) || lastCoverLanguage;

// 当前语言 {zh: '', en: '', ja: '', ko: ''} 格式数据
export function DefaultLang() {
  // 初始化语言种类数据
  let data = {};
  for (let item of languages) {
    data[item.languageKey] = '';
  }
  return data;
}

// 没有翻译数据情况下，系统字段或关键字段使用 fieldName 做键值，自定义字段使用 formType 做键值
export const SystemLibrary = [
  // 仓库系统字段
  'sn', //物料ID
  'name', //物料名称
  'property', //物料属性
  'snManage', //是否SN管理
  'images', //图片
  'returnType', //物料返还类型
  'standard', //规格
  'type', //类型
  'description', //说明
  // 仓库关键字段
  'forSale', //是否销售
  'costPrice', //成本价
  'channelPrice', //渠道价
  'depositPrice', //押金控制价
  'salePrice', //终端销售价
  'unit', //物料单位
  'productCatalog' // 产品类型
];

// 语言库数据 Start

let laList = Object.keys(oldLanguage);
let message_ = {};
let messageMap_ = {};
laList.forEach(item => {
  message_[item] = oldLanguage[item].oldLa;
  messageMap_[item] = new Map();
});

export const message = message_;
export const messageMap = messageMap_;

/** 根据message语言库获取Map值
 *  以 emali.allocationTitle:'1111' 的形式保存数据
 * */
(function() {
  for (let lang in message) {
    let source = message[lang];
    // 遍历语言库 以 emali.allocationTitle:'1111' 的形式保存数据
    deep(lang, source, []);
  }

  function deep(lang, source, route) {
    for (let i in source) {
      if (typeof source[i] === 'object') {
        deep(lang, source[i], [...route, i]);
      } else {
        let routes = [...route, i].join('.');
        if (!messageMap[lang].has(routes)) {
          messageMap[lang].set(routes, source[i]);
        }
      }
    }
  }
})();

// 语言库数据 End

// 语言库查找数据 Start
/** 根据 formType 去默认语言库中查询对应的语言
 * @param formType 语言库路径
 * @param language 语言，没有就取 defaultCNKey
 * @return 获取到语言库的数据，没有就空值
 * */
export function GetTransformI18n({ formType = '', language = '' }) {
  // 没有对应键值
  if (!formType) {
    return '';
  }
  let lang = messageMap[language || defaultCNKey];
  try {
    if (lang) {
      if (lang.has(formType)) {
        return lang.get(formType);
      } else {
        // 路径不对
        console.error(`语言库中参数路径查找不到，${formType}`);
        return '';
      }
    } else {
      // 语言库中没有该语言
      console.error(`语言库中不支持${language}`);
      return '';
    }
  } catch (error) {}
}

/** 多语言 key-value 对象
 *  @return { 'zh-CN': '', 'en-US': '', 'ja': '', 'ko': ''}
 *  @parames formType 语言库对应路径
 *  @parames lastValue 老数据，有老数据直接返回
 *  老数据接收 String 和 Object
 *  String 识别为中文，填充返回
 *  Object 识别为中文，直接返回
 * */
export function GetCommonDefaultLang({ formType, lastValue }) {
  // 获取多语言列表
  const Language = languages;

  let Obj = {};
  Obj[defaultCNKey] = '';
  if (Language.length) {
    for (let item of Language) {
      const language = item.languageKey;
      if (formType) {
        /** 根据 formType 获取 默认语言库中对应的参数
         * */
        Obj[item.languageKey] = GetTransformI18n({
          formType,
          language
        });
      } else {
        Obj[item.languageKey] = '';
      }
    }
  }
  // 老数据处理
  if (![null, undefined].includes(lastValue)) {
    // 老数据标题不与翻译库字段相同，就使用老数据直接替换
    if (typeof lastValue === 'string' && Obj[defaultCNKey] !== lastValue) {
      // 直接替换中文数据
      Obj[defaultCNKey] = lastValue;
    }
    if (typeof lastValue === 'object') {
      Obj = lastValue;
    }
  }

  return Obj;
}

// 语言库查找数据 End

// 多选数据处理 Start
// 处理 多选option 数据，数据回填
export function initOptionLanguage({ dataSourceLanguage, options }) {
  if (dataSourceLanguage) {
    // 有数据
    options.map((item, index) => {
      let data = {};
      Object.keys(dataSourceLanguage).forEach(key => {
        data[key] = dataSourceLanguage[key][index];
      });
      item.language = {
        [defaultCNKey]: item.value,
        ...data
      };
      return item;
    });
    return options;
  } else {
    // 没数据
    options.map(item => {
      item.language = {
        ...DefaultLang(),
        [defaultCNKey]: item.value
      };
      return item;
    });
    return options;
  }
}

/**
 * @description: 格式化option 生成标准的optionsLanguage
 * @param {Object} options 选项对象
 * @return optionsLanguage
 */
export function formatLanguage(options) {
  const langKey = `language`;
  if (!options) return [];
  let langOpts = getDefaultLangOpts();
  let OPTS = _.cloneDeep(options);
  OPTS.forEach(opt => {
    if (!opt[langKey]) return;
    Object.keys(opt[langKey]).forEach(key => {
      if (!langOpts[key]) return;
      langOpts[key].push(opt[langKey][key]);
    });
  });
  return langOpts;
}

/**
 * @description: 生成选项or多级联动的多语言树根节点
 * @return xxxLanguage { 'zh-CN': [], 'en-US': [], 'ja': [], 'ko': []}
 */
export function getDefaultLangOpts() {
  const language = DefaultLang();
  let obj = {};
  for (let i in language) {
    obj[i] = [];
  }
  return obj;
}
// 多选数据处理 End


export const deepTranslateByKey = (translate, la) => {
  try {
    let data = _.cloneDeep(translate);
    if(typeof data === 'string'){
      if (data) {
        // 不是国际化翻译参数
        if(!data.includes('.')) return data;
        return transformI18n(`${data}`, la) || '';
      } else {
        return '';
      }
    }else if(typeof data === 'object'){
      for(let key in data){
        data[key] = deepTranslateByKey(data[key], la);
      }
      return data;
    }
  } catch (error) {
    console.warn(error, 'error try catch deepTranslateByKey');
  }
}

export function getCommonDefaultLangForKey(data) {
  const obj = {};
  languages.forEach((item) => {
    obj[item.languageKey] = deepTranslateByKey(data, item.languageKey);
  });
  return obj;
}


function getCurrentValueToShow(v, setting) {
  let index = -1;
  let languageSource = !setting?.dataSourceLanguage?.zh?.length ? setting?.dataSource : setting?.dataSourceLanguage?.zh;

  let data = internationalGray ? languageSource : setting?.dataSource;

  data?.forEach((zitem, zindex) => {
    if ((isObject(zitem) && zitem.value === v) || (zitem === v)) index = zindex;
  });

  let currentItem = setting?.dataSource?.[index];
  if (isObject(currentItem)) return currentItem?.text || currentItem?.label || v
  return currentItem || v;
}
// 用来页面显示(列表，详情，编辑显示)：下拉选择一些中文字段需要去拿到对应的英文（根据当前的中文value值去dataSourceLanguage的zh中拿到对应的下标位置，然后根据下标再去dataSource拿到对应的翻译后的值）
export function handleSelectData(field, value) {
  let setting = field?.setting;
  if (isArray(value)) {
    let currentValue = value.map(v => {
      return getCurrentValueToShow(v, setting)
    });
    return currentValue || value;
  } else {
    return getCurrentValueToShow(value, setting)
  }
}